package org.jeecg.modules.student.controller;

import java.text.ParseException;
import java.util.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.system.api.ISysBaseAPI;
import org.jeecg.common.system.util.JwtUtil;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.classes.entity.CouClass;
import org.jeecg.modules.classes.service.ICouClassService;
import org.jeecg.modules.common.api.ISysInfo;
import org.jeecg.modules.common.baseentity.BaseApiEntity;
import org.jeecg.modules.common.utils.BeanObjUtil;
import org.jeecg.modules.common.utils.DateUtil;
import org.jeecg.modules.common.utils.MapBeanUtils;
import org.jeecg.modules.relation.relclassstudent.entity.RelClassStudent;
import org.jeecg.modules.relation.relclassstudent.service.IRelClassStudentService;
import org.jeecg.modules.student.entity.StuStudent;
import org.jeecg.modules.student.entity.StuStudentDemo;
import org.jeecg.modules.student.service.IStuStudentService;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;

import org.jeecg.modules.student.vo.StuStudentVo;
import org.jeecg.common.system.base.controller.JeecgController;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.jeecg.common.aspect.annotation.AutoLog;

/**
 * @Description: stu_student
 * @author: baochangrong
 * @Date: 2022-02-15
 * @Version: V1.0
 */
@Api(tags = "stu_student")
@RestController
@RequestMapping("/student/stuStudent")
@Slf4j
public class StuStudentController extends JeecgController<StuStudent, IStuStudentService> {
    @Autowired
    private IStuStudentService stuStudentService;
    @Autowired
    private IRelClassStudentService relClassStudentService;
    @Autowired
    private ISysBaseAPI sysBaseAPI;
    @Autowired
    private ISysInfo sysInfo;
    @Autowired
    ICouClassService couClassService;

    /**
     * 分页列表查询
     *
     * @param stuStudentVo
     * @param pageNo
     * @param pageSize
     * @param req
     * @return
     */
    @AutoLog(value = "stu_student-分页列表查询")
    @ApiOperation(value = "stu_student-分页列表查询", notes = "stu_student-分页列表查询")
    @GetMapping(value = "/list")
    public Result<?> queryPageList(StuStudentVo stuStudentVo,
                                   @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                   @RequestParam(name = "pageSize", defaultValue = "50") Integer pageSize,
                                   HttpServletRequest req) {

        //组装vo以外的其他参数
        Map<String,String> queryParam = sysInfo.getMapQueryParamByReq(req);
        //获取当前登录用户信息 把租户 部门 身份 学期 学年等基本信息信息赋值克隆给vo
        BaseApiEntity baseApiEntity = sysInfo.querySysInfoCloneObj(req,stuStudentVo,false); //获取当前登录用户信息 把租户 部门 身份 学期 学年等基本信息信息赋值给vo
        //根据用户身份设置对象属性值：例如：老师只能查看部门下数据，班级用户只能看自己班级数据，学生只能看自己成绩，家长只能看孩子的数据(可能是多个孩子)
        stuStudentVo = reSetObjectValue(baseApiEntity,stuStudentVo);
        //是否忽略学期学年:忽略学期学年
        if(oConvertUtils.isNotEmpty(queryParam.get("ignoreProperty")) ){
            if(queryParam.get("ignoreProperty").indexOf("1") != -1 ){
                stuStudentVo.setSchoolYearId(null); //忽略学年
            }
            if(queryParam.get("ignoreProperty").indexOf("2") != -1 ){
                stuStudentVo.setSemesterId(null);//忽略学期
            }
            if(queryParam.get("ignoreProperty").indexOf("3") != -1 ){
                stuStudentVo.setSysOrgCode(null);//忽略部门
                stuStudentVo.setSubDepSysOrgCodes(null);
            }

            if(queryParam.get("ignoreProperty").indexOf("4") != -1 ){
                stuStudentVo.setStudentEnrollmentYear(null);//忽略届级
            }
        }

        //执行查询
        Page<StuStudentVo> page = new Page<StuStudentVo>(pageNo, pageSize);
        IPage<StuStudentVo> pageList = stuStudentService.queryStuStudentVoLists(page, queryParam, stuStudentVo);

        return Result.OK(pageList);
    }

    /**
     * 分页列表查询
     *
     * @param stuStudentVo
     * @param req
     * @return
     */
    @AutoLog(value = "stu_student-分页列表查询")
    @ApiOperation(value = "stu_student-分页列表查询", notes = "stu_student-分页列表查询")
    @GetMapping(value = "/listBatchNumber")
    public Result<List<Map>> listBatchNumber(StuStudentVo stuStudentVo,
                                             HttpServletRequest req) {
        //获取当前登录用户信息
        String token = req.getHeader(CommonConstant.X_ACCESS_TOKEN);
        String username = JwtUtil.getUsername(token);
        //		SysUser sysUser = sysUserService.getOneUser(username);// sysBaseAPI.getUserByName(username); 不能直接引用system模块，需使用APi调用
        LoginUser loginUser = sysBaseAPI.getUserByName(username); //.getUserById() 获取登录用户
        String tenantId = req.getHeader("tenant-id");//获取当前登录用户的租户id
        String sysOrgCode = loginUser.getOrgCode();//获取当前用户的当前的部门编码（不是id是编码）,该编码随前端切换
        String departId = sysBaseAPI.getDepartIdsByOrgCode(sysOrgCode);//获取当前用户设置的部门id
        List<String> subDepIdsList = sysBaseAPI.getSubDepIdsByDepId(departId); //获取下级部门的部门id，自定义改造sysBaseAPI
        String subDepSysOrgCodes = sysBaseAPI.getSubDepOrgCodesByDepId(departId); //直接获取下级部门的orgcode，自定义改造sysBaseAPI
        int userIdentity = loginUser.getUserIdentity();  //获取当前登录用户身份：字典码 user_identity
        //userIdentity 用户身份字典码user_identity， 3教师 4学生 1普通用户 2上级部门负责人 5家长 6班级

        stuStudentVo.setTenantId(tenantId);
        stuStudentVo.setSysOrgCode(subDepSysOrgCodes);
        stuStudentVo.setStudentIzDelete(0);//未删除

//		//userIdentity 用户身份字典码user_identity， 3教师 4学生 1普通用户 2上级部门负责人 5家长 6班级
        if (userIdentity == 3 || userIdentity == 1 || userIdentity == 2) {
            //普通用户和老师用户，可以查看自己部门及下级部门的的数据
            stuStudentVo.setSysOrgCode(subDepSysOrgCodes);
        } else if (userIdentity == 4) {
            //学生身份只能查看自己的数据
            StuStudent student = stuStudentService.getStuStudentByUserId(loginUser.getId()); //获取学生的学生id
            stuStudentVo.setId(student.getId());
        } else if (userIdentity == 5) {
            //家长身份只能查看自己孩子的数据
            String studentIds = loginUser.getId(); //获取家长的孩子id
            stuStudentVo.setId(studentIds);
        } else if (userIdentity == 6) {
            //班级身份只能查看自己班级的数据
            CouClass classId = couClassService.getCouClassByUserID(loginUser.getId());//获取班级id
            stuStudentVo.setClassId(classId.getId());
        } else {
            stuStudentVo.setSysOrgCode(subDepSysOrgCodes);
        }
        return stuStudentService.listBatchNumber(stuStudentVo);
    }

    /**
     * 学生相关  全查询
     * classStudentQueryAll
     */
    @AutoLog(value = "stu_student-列表查询")
    @ApiOperation(value = "stu_student-列表查询", notes = "stu_student-列表查询")
    @GetMapping(value = "/classStudentQueryAll")
    public Result<?> classStudentQueryAll(StuStudent stuStudent,
                                          HttpServletRequest req) {
        String tenantId = req.getHeader("tenant-id");
        List<StuStudent> stuStudentList = stuStudentService.classStudentQueryAll(tenantId);
        return Result.OK(stuStudentList);
    }

    /**
     * 添加
     *
     * @param stuStudentVo
     * @return
     */
    @AutoLog(value = "stu_student-添加")
    @ApiOperation(value = "stu_student-添加", notes = "stu_student-添加")
    @PostMapping(value = "/add")
    public Result<?> add(@RequestBody StuStudentVo stuStudentVo,
                         HttpServletRequest req) {
        //添加班级学生关系，即分班
        //获取当前登录用户信息 把租户 部门 身份 学期 学年等基本信息信息赋值克隆给vo
        BaseApiEntity baseApiEntity = sysInfo.querySysInfoCloneObj(req,stuStudentVo); //获取当前登录用户信息 把租户 部门 身份 学期 学年等基本信息信息赋值给vo

        StuStudent stuStudent = new StuStudent(stuStudentVo);
//        BeanObjUtil.copyDeepCloneProperties(stuStudentVo,stuStudent);
        stuStudentService.save(stuStudent);
        //先保存学生获得student_id
        stuStudentVo.setId(stuStudent.getId());
        RelClassStudent relClassStudent = new RelClassStudent();//stuStudentVo);
        relClassStudent.setClassId(stuStudentVo.getClassId());
        relClassStudent.setStudentId(stuStudent.getId());
        relClassStudent.setSchoolYearId(stuStudentVo.getSchoolYearId());
        relClassStudent.setSemesterId(stuStudentVo.getSemesterId());
        relClassStudent.setTenantId(stuStudentVo.getTenantId());
        relClassStudent.setClassStudentStatus(1);
//        relClassStudent.setClassName(stuStudentVo.get) //班级名称：保留名称字段

        relClassStudentService.saveByStuStudentVo(stuStudentVo);
        return Result.OK("添加成功！");
    }

    /**
     * 编辑
     *
     * @param stuStudentVo
     * @return
     */
    @AutoLog(value = "stu_student-编辑")
    @ApiOperation(value = "stu_student-编辑", notes = "stu_student-编辑")
    @PutMapping(value = "/edit")
    public Result<?> edit(@RequestBody StuStudentVo stuStudentVo,
                          HttpServletRequest req) {
        //待补充：修改或添加班级学生关系，即分班
        //获取当前登录用户信息 把租户 部门 身份 学期 学年等基本信息信息赋值克隆给vo
        BaseApiEntity baseApiEntity = sysInfo.querySysInfoCloneObj(req,stuStudentVo); //获取当前登录用户信息 把租户 部门 身份 学期 学年等基本信息信息赋值给vo
        stuStudentVo.setSchoolYearId(baseApiEntity.getSchoolYearId()); //更新学期学年
        stuStudentVo.setSemesterId(baseApiEntity.getSemesterId());
        //修改学生的班级时：需要知道旧的班级、学期、学年和学生id，唯一定位一条关系表中的数据，然后才能更改，不能随意更改学生的班级
        relClassStudentService.saveOrupdateByStuStudentVo(stuStudentVo);
        StuStudent stuStudent = new StuStudent(stuStudentVo);
        stuStudentService.updateById(stuStudent);
        return Result.OK("编辑成功!");
    }

    /**
     * 通过id删除
     *
     * @param id
     * @return
     */
    @AutoLog(value = "stu_student-通过id删除")
    @ApiOperation(value = "stu_student-通过id删除", notes = "stu_student-通过id删除")
    @DeleteMapping(value = "/delete")
    public Result<?> delete(@RequestParam(name = "id", required = true) String id) {
        StuStudent stuStudent = new StuStudent();
        stuStudent.setId(id);
        stuStudent.setStudentIzDelete(1);
        stuStudent.setStudentIzOpen(0);
        stuStudentService.updateById(stuStudent);
        return Result.OK("删除成功!");
    }

    /**
     * 批量删除
     *
     * @param ids
     * @return
     */
    @AutoLog(value = "stu_student-批量删除")
    @ApiOperation(value = "stu_student-批量删除", notes = "stu_student-批量删除")
    @DeleteMapping(value = "/deleteBatch")
    public Result<?> deleteBatch(@RequestParam(name = "ids", required = true) String ids) {
        String[] idsPlus = ids.split(",");
        List<StuStudent> stuStudentList = new ArrayList<>();
        for (int i = 0; i < idsPlus.length; i++) {
            StuStudent stuStudent = new StuStudent();
            stuStudent.setId(idsPlus[i]);
            stuStudent.setStudentIzDelete(1);
            stuStudent.setStudentIzOpen(0);
            stuStudentList.add(stuStudent);
        }
        this.stuStudentService.updateBatchById(stuStudentList);
        return Result.OK("批量删除成功!");
    }

    /**
     * 通过id查询
     *
     * @param id
     * @return
     */
    @AutoLog(value = "stu_student-通过id查询")
    @ApiOperation(value = "stu_student-通过id查询", notes = "stu_student-通过id查询")
    @GetMapping(value = "/queryById")
    public Result<?> queryById(@RequestParam(name = "id", required = true) String id) {
        StuStudent stuStudent = stuStudentService.getById(id);
        if (stuStudent == null) {
            return Result.error("未找到对应数据");
        }
        return Result.OK(stuStudent);
    }

    /**
     * 导出excel
     *
     * @param request
     * @param stuStudent
     */
    @RequestMapping(value = "/exportXls")
    public ModelAndView exportXls(HttpServletRequest request, StuStudent stuStudent) {
        return super.exportXls(request, stuStudent, StuStudent.class, "stu_student");
    }

    /**
     * 下载模板文件excel
     *
     * @param request
     * @param stuStudentDemo
     */
    @RequestMapping(value = "/exportXlsDemo")
    public ModelAndView exportXlsDemo(HttpServletRequest request, StuStudentDemo stuStudentDemo){
        stuStudentDemo.setStudentNo("20220601001");
        stuStudentDemo.setStudentName("张三");
        stuStudentDemo.setStudentEnrollmentYear("2022");
        stuStudentDemo.setStudentOrder("1");
        stuStudentDemo.setStudentCardNo("632122202206204569");
        stuStudentDemo.setStudentNationalityNo("G632122202206204569");
        stuStudentDemo.setStudentGender(2);
        stuStudentDemo.setStudentNation(1);
        stuStudentDemo.setStudentTtype(1);
        stuStudentDemo.setStudentPoor(0);
        stuStudentDemo.setStudentLoan(0);
        stuStudentDemo.setStudentStatus(1);
        stuStudentDemo.setStudentFamilyStatus(1);
        stuStudentDemo.setStudentDateBirth(DateUtil.getCurrentDate());
        //字典字段，字典编码请写入到这里
        JSONObject DictList = new JSONObject();
        DictList.put("年级ID", "gradeId");
        DictList.put("学生性别", "sex");
        DictList.put("民族", "common_nation");
        DictList.put("学生类型", "student_ttype");
        DictList.put("家庭状态", "student_family_status");
        DictList.put("是否贫困生", "student_poor");
        DictList.put("贫困级别", "student_poor_level");
        DictList.put("是否借读生", "student_load");
        DictList.put("学生状态", "student_status");
        String secondTitle = "学生姓名,身份证号,入学年份,年级ID 为必填项，请严格按照要求填写。" +
                "填写前仔细阅读下本说明，务必严格按照该格式填写: " +
                "填中文值后面的编码(列如性别是女则填写2)，否则数据导入将出现失败! 当然除了必填项其他字段可以不填，导入系统后在系统中进行维护。";
        return stuStudentService.exportXlsDemo(request, stuStudentDemo, "学生信息导入", secondTitle, sysBaseAPI, DictList);
    }

    /**
     * 通过excel导入数据
     *
     * @param request
     * @param response
     * @return
     */
    @RequestMapping(value = "/importExcelDemo", method = RequestMethod.POST)
    public Result<?> importExcelDemo(HttpServletRequest request, HttpServletResponse response) {
        BaseApiEntity baseApiEntity = this.querySysInfo(request);
        return stuStudentService.importExcelDemo(request, response, stuStudentService, baseApiEntity);
    }

    /**
     * 通过excel导入数据
     *
     * @param request
     * @param response
     * @return
     */
    @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
    public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
        return super.importExcel(request, response, StuStudent.class);
    }


    @ApiOperation(value = "stu_student-查询没有班级的学生", notes = "查询没有班级的学生")
    @GetMapping(value = "/noClassStudentsList")
    public Result<?> noClassStudentsList(HttpServletRequest req) {
        String tenantId = req.getHeader("tenant-id");
        List<StuStudent> list = stuStudentService.noClassStudentsList(tenantId);
        return Result.OK(list);
    }

    /**
     * 添加用户
     *
     * @param addUserParm
     * @return
     */
    @AutoLog(value = "stu_student-添加用户")
    @ApiOperation(value = "stu_student-添加用户", notes = "stu_student-添加用户")
    @PostMapping(value = "/addUsers")
    public Result<?> addUsers(@RequestBody Object addUserParm, HttpServletRequest req) {
        //添加学生账号
        String addUserParmStr = JSONObject.toJSONString(addUserParm);
        Map addUserParmMap = JSONObject.parseObject(JSONObject.toJSONString(addUserParm), Map.class);

//		 JSONObject parm =  JSONObject.toJSON(addUserParm);
        String stupassword = addUserParmMap.get("stupassword").toString();
        String ids = addUserParmMap.get("ids").toString();

        //获取当前登录用户信息
        String token = req.getHeader(CommonConstant.X_ACCESS_TOKEN);
        String username = JwtUtil.getUsername(token);
        //        SysUser sysUser = sysUserService.getOneUser(username);// sysBaseAPI.getUserByName(username); 不能直接引用system模块，需使用APi调用
        LoginUser loginUser = sysBaseAPI.getUserByName(username); //.getUserById() 获取登录用户
        String tenantId = req.getHeader("tenant-id");//获取当前登录用户的租户id
//		 String sysOrgCode = loginUser.getOrgCode();//获取当前用户的当前的部门编码（不是id是编码）,该编码随前端切换
//		 String departId = sysBaseAPI.getDepartIdsByOrgCode(sysOrgCode);//获取当前用户设置的部门id
//		 List<String> subDepIdsList = sysBaseAPI.getSubDepIdsByDepId(departId); //获取下级部门的部门id，自定义改造sysBaseAPI
//		 String subDepSysOrgCodes = sysBaseAPI.getSubDepOrgCodesByDepId(departId); //直接获取下级部门的orgcode，自定义改造sysBaseAPI
        //userIdentity 用户身份字典码user_identity， 3教师 4学生 1普通用户 2上级部门负责人 5家长 6班级
//		 int userIdentity = loginUser.getUserIdentity();//获取当前登录用户身份：字典码 user_identity
//		 List idsli =Arrays.asList(ids.split(","));
//		 List idList = Arrays.asList(ids.split(",")) ;
        stuStudentService.createUserByStudentIds(tenantId, stupassword, ids, loginUser, false);
        return Result.OK("添加成功！");
    }

    /**
     * 学生批量调整部门
     *
     * @param requestParm
     * @param req
     * @return
     */
    @AutoLog(value = "stu_student-学生批量调整部门")
    @ApiOperation(value = "stu_student-学生批量调整部门", notes = "stu_student-学生批量调整部门")
    @PostMapping(value = "/changeSysOrgCode")
    public Result<?> changeSysOrgCode(@RequestBody Object requestParm, HttpServletRequest req) {
        //@RequestBody Object requestParm,
        Map requestParmMap = JSONObject.parseObject(JSONObject.toJSONString(requestParm), Map.class);
//        StuStudentVo stuStudentVo = new StuStudentVo();
//        BeanUtils.copyProperties(requestParm,stuStudentVo);//拷贝属性,map类型无法复制
        //此map给vo赋值的函数：可以考虑map转vo，或json转vo
        StuStudentVo stuStudentVo = MapBeanUtils.map2Bean(StuStudentVo.class,requestParmMap);

            //获取当前登录用户信息 把租户 部门 身份 学期 学年等基本信息信息赋值克隆给vo
//            BaseApiEntity baseApiEntity = sysInfo.querySysInfoCloneObj(req,stuStudentVo); //获取当前登录用户信息 把租户 部门 身份 学期 学年等基本信息信息赋值给vo

//		 String requestParmStr = JSONObject.toJSONString(requestParm);
//        Map requestParmMap = JSONObject.parseObject(JSONObject.toJSONString(requestParm), Map.class);

        String ids = requestParmMap.get("ids").toString();
        boolean updateFlag = false;
        LambdaUpdateWrapper<StuStudent> studentUpdateWrapper = new UpdateWrapper<StuStudent>()
                .lambda()
                .in(StuStudent::getId, Arrays.asList(ids.split(",")));
        //更新部门
        if(oConvertUtils.isNotEmpty(stuStudentVo.getSysOrgCode())){
            studentUpdateWrapper.set(StuStudent::getSysOrgCode,stuStudentVo.getSysOrgCode());
            updateFlag = true;
        }
        //更新届级
        if(oConvertUtils.isNotEmpty(stuStudentVo.getStudentEnrollmentYear())){
            studentUpdateWrapper.set(StuStudent::getStudentEnrollmentYear,stuStudentVo.getStudentEnrollmentYear());
            updateFlag = true;
        }
        //更新状态
        if(oConvertUtils.isNotEmpty(stuStudentVo.getStudentStatus())){
            studentUpdateWrapper.set(StuStudent::getStudentStatus,stuStudentVo.getStudentStatus());
            updateFlag = true;
        }
        //需要更新则更新
        if( updateFlag ){
            stuStudentService.update(studentUpdateWrapper);
        }
        updateFlag = false;

        //更新班级、学年、学期、班级：更新关系表的时候会把历史数据更新掉，是不正确的。需要精确更新
        //知道旧的学期和学年，然后根据旧的学期学年精确查到想要更改的数据，然后进行更改

//        LambdaUpdateWrapper<RelClassStudent> relClassStudentUpdateWrapper = new UpdateWrapper<RelClassStudent>()
//                .lambda()
//                .in(RelClassStudent::getStudentId, Arrays.asList(ids.split(",")));
//
//        //更新学年：关系表
//        if(oConvertUtils.isNotEmpty(stuStudentVo.getSchoolYearId())){
//            relClassStudentUpdateWrapper.set(RelClassStudent::getSchoolYearId,stuStudentVo.getSchoolYearId());
//            updateFlag = true;
//        }
//        //更新学期：关系表
//        if(oConvertUtils.isNotEmpty(stuStudentVo.getSemesterId())){
//            relClassStudentUpdateWrapper.set(RelClassStudent::getSemesterId,stuStudentVo.getSemesterId());
//            updateFlag = true;
//        }
//        //更新班级：关系表
//        if(oConvertUtils.isNotEmpty(stuStudentVo.getClassId())){
//            relClassStudentUpdateWrapper.set(RelClassStudent::getClassId,stuStudentVo.getClassId());
//            updateFlag = true;
//        }
//
//        //需要更新则更新
//        if( updateFlag ){
//            relClassStudentService.update(relClassStudentUpdateWrapper);
//        }
//        //更新年级:班级表中更新：此处不合理不能更改学生的年级，只能更改班级的年级


        return Result.OK("调整成功!");
    }

    /**
     * 从request获取 token 用户信息，组织信息
     *
     * @param req
     * @return
     */
    public BaseApiEntity querySysInfo(HttpServletRequest req) {

        BaseApiEntity baseApiEntity = new BaseApiEntity();

        //获取当前登录用户信息
        String token = req.getHeader(CommonConstant.X_ACCESS_TOKEN);
        String username = JwtUtil.getUsername(token);
        baseApiEntity.setUsername(username);
        baseApiEntity.setCreateBy(username);
        baseApiEntity.setUpdateBy(username);

        LoginUser loginUser = sysBaseAPI.getUserByName(username); //.getUserById() 获取登录用户
        baseApiEntity.setLoginUser(loginUser);
        String sysOrgCode = loginUser.getOrgCode();//获取当前用户的当前的部门编码（不是id是编码）,该编码随前端切换
        String tenantId = req.getHeader("tenant-id");//获取当前登录用户的租户id
        baseApiEntity.setTenantId(tenantId);

        String departId = sysBaseAPI.getDepartIdsByOrgCode(sysOrgCode);//获取当前用户设置的部门id
        List<String> subDepIdsList = sysBaseAPI.getSubDepIdsByDepId(departId); //获取下级部门的部门id，自定义改造sysBaseAPI
        baseApiEntity.setSysOrgCode(sysOrgCode);
        baseApiEntity.setSubDepIdsList(subDepIdsList);
        String subDepSysOrgCodes = sysBaseAPI.getSubDepOrgCodesByDepId(departId); //直接获取下级部门的orgcode，自定义改造sysBaseAPI
        baseApiEntity.setSubDepSysOrgCodes(subDepSysOrgCodes);
        //userIdentity 用户身份字典码user_identity， 3教师 4学生 1普通用户 2上级部门负责人 5家长 6班级
        int userIdentity = loginUser.getUserIdentity();//获取当前登录用户身份：字典码 user_identity
        baseApiEntity.setUserIdentity(userIdentity);

        return baseApiEntity;
    }
    /**
     *
     * 有需要身份识别的业务需打开下方注释补充查询条件就可以了
     * 根据业务需要设置查询参数，不同身份的用户不同的查询参数、得到不同的查询结果
     * 注意：有些业务并不需要身份识别，有些业务必须识别身份:4学生用户只能查自己的数据不能查别人的，6班级用户只能查自己班级的数据不能查其他班级的数据，
     * 3老师只能查老师所在部门和下级部门的数据，1普通用户（一般是非教学用户）
     * @param baseApiEntity
     * @return Object
     */
    private StuStudentVo reSetObjectValue(BaseApiEntity baseApiEntity,StuStudentVo stuStudentVo){
        //1.获取用户身份 userIdentity loginUser.getUserIdentity() 用户身份字典码user_identity， 3教师 4学生 5家长 6班级  1普通用户 2上级部门负责人
        //2.获取用户id loginUser.getId()
        int userIdentity = baseApiEntity.getUserIdentity();//获取当前登录用户身份：字典码 user_identity，3教师 4学生 5家长 6班级  1普通用户 2上级部门负责人
        String userId = baseApiEntity.getLoginUser().getId(); //当前登录用户id

        //有需要身份识别的业务需打开下方注释补充查询条件就可以了
        //根据业务需要设置查询参数，不同身份的用户不同的查询参数、得到不同的查询结果
        //注意：有些业务并不需要身份识别，有些业务必须识别身份:4学生用户只能查自己的数据不能查别人的，6班级用户只能查自己班级的数据不能查其他班级的数据，3老师只能查老师所在部门和下级部门的数据，1普通用户（一般是非教学用户） 2上级部门负责人只能查所在部门和下级部门的数据

        //  //userIdentity 用户身份字典码user_identity， 3教师 4学生 5家长 6班级  1普通用户 2上级部门负责人
        // // 学生、老师、班级、家长，都有绑定用户的user_id字段，可以根据user_id查询到对应的学生、老师、班级 基础档案信息
        if (userIdentity ==4 ){
            //学生身份只能查看自己班级的数据
            CouClass couClass = couClassService.getCouClassByUserID(userId);
            //StuStudent student = stuStudentService.getStuStudentByUserId(userId);
            stuStudentVo.setClassId(couClass.getId());
            stuStudentVo.setSysOrgCode(null);
            stuStudentVo.setSubDepSysOrgCodes(null);
            //当前用户和业务数据可能不在同一个部门，需设置为null，例如：学生张三属于七年级部门，成绩数据在初中教学部
        }
        else if (userIdentity == 5 ){
            //家长身份只能查看孩子的数据，注意一个家长可能有多个孩子 一个孩子属于多个家长
            //家长身份只能查看孩子的数据
            String classIds = userId; //获取家长的孩子的班级id
            stuStudentVo.setClassId(classIds);
            stuStudentVo.setSysOrgCode(null); //当前用户和业务数据可能不在同一个部门，需设置为null，例如：家长属于家长部，学生张三属于七年级部门，成绩数据在初中教学部
            stuStudentVo.setSubDepSysOrgCodes(null);
        }
        else if (userIdentity == 6 ){
            //班级身份只能查看自己班级的数据
//			String classId = loginUser.getId();//获取班级id
            CouClass couClass = couClassService.getCouClassByUserID(userId);
            stuStudentVo.setClassId(couClass.getId());
            stuStudentVo.setSysOrgCode(null); //当前用户和业务数据可能不在同一个部门，需设置为null，例如：某班级属于七年级部门，成绩数据在初中教学部
            stuStudentVo.setSubDepSysOrgCodes(null);
        }
        else if ( userIdentity == 3 ){
            //老师身份，可以查看当前部门和下级子集部门的数据
            //(如果考虑老师只能查看所教授科目、所教授班级学生的数据，则与普通用户有区分，否则是一样的)
            stuStudentVo.setSysOrgCode(null);
            stuStudentVo.setSubDepSysOrgCodes(baseApiEntity.getSubDepSysOrgCodes());
        }
        else if ( userIdentity == 3 ){
            //老师身份，可以查看当前部门和下级子集部门的数据
            //考虑老师按照所教授班级的权限查询的话，可以在这里设置
            stuStudentVo.setSysOrgCode(null);
            stuStudentVo.setSubDepSysOrgCodes(baseApiEntity.getSubDepSysOrgCodes());
        }
        else if ( userIdentity == 1 || userIdentity == 2 ){
            //普通用户身份、部门负责人（领导），可以查看当前部门和下级子集部门的数据
            stuStudentVo.setSysOrgCode(null);
            stuStudentVo.setSubDepSysOrgCodes(baseApiEntity.getSubDepSysOrgCodes());
        }
        else{
            //其他身份或默认设置
            stuStudentVo.setSysOrgCode(null);
            stuStudentVo.setSubDepSysOrgCodes(baseApiEntity.getSubDepSysOrgCodes());
        }
        return stuStudentVo;
    }
}
